package net.jcip.examples.chapter5;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class synchronizedList {


    class Widget {

        public void doSomething() {
            System.out.println("doSomething");
        }
    }

    /**
     * 即使每个线程在对widgetList操作时，都显示调用Collections.synchronizedList（）获取加锁版的list，但是仍然不能避免ConcurrencyModificationException
     *
     *
     *
     *Collections.synchronizedList() 的实现大致如下：
     *
     *
     * static class SynchronizedList<E> implements List<E>, Serializable {
     *     final List<E> list;
     *     final Object mutex;
     *
     *     SynchronizedList(List<E> list) {
     *         this.list = list;
     *         this.mutex = this;
     *     }
     *
     *     public boolean add(E e) {
     *         synchronized (mutex) { return list.add(e); }
     *     }
     *
     *     public E get(int index) {
     *         synchronized (mutex) { return list.get(index); }
     *     }
     *
     *     public Iterator<E> iterator() {
     *         return list.iterator(); // ❗ 注意：迭代器本身没有同步
     *     }
     * }
     *
     * 每个方法确实都在 mutex 上加锁，但有一个例外：
     *
     * iterator() 方法只是返回底层集合的迭代器，它并没有加锁。
     *
     * 这意味着：
     * 当你执行 for (E e : list) 时，编译器会调用 iterator()，获得一个“未同步的”迭代器对象。
     * 而在迭代过程中，其他线程仍然可能通过同步代理执行修改操作（add、remove 等），
     * 导致底层结构被修改，从而触发 ConcurrentModificationException。
     *
     *
     *
     * @param args
     */
    public static void main(String[] args){
        List<Widget> widgetsList = new ArrayList<>();

        List<Widget> synchronizedWidgets = Collections.synchronizedList(widgetsList);
        for (Widget widget : synchronizedWidgets){
            widget.doSomething();
        }



        //1. 使用CopyOnWriteArrayList


        //2. 使用并发容器
        //如果数据结构是队列或映射：
        //	•	ConcurrentLinkedQueue
        //	•	ConcurrentHashMap
        //	•	ConcurrentSkipListMap
        //等容器都能提供无锁或细粒度锁的并发安全迭代。

    }



}
